In [1]:
from google.colab import drive
drive.mount('/content/drive')
In [2]:
cd drive/MyDrive/project_files/
In [3]:
ls
In [4]:
import csv
import json
import os
from PIL import Image
import pprint
import skimage.draw
import visualize
import utils as my_utils
import matplotlib.pyplot as plt
import cv2
import numpy as np
import tensorflow as tf
from tensorflow.keras.layers import *
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
from tensorflow.keras.optimizers import Adam
from IPython.display import clear_output
Data structures¶
In [5]:
# global context variables
anno_path = './data/csv' # a folder of annotation files
img_path = './data/images' # a folder of image files
In [6]:
class annotation:
# label: the class label
# xcoords: list of x-coordinates of a polygon
# ycoords: list of y-coordinates of a polygon
def __str__(self):
return '* label: ' + self.label + '\n xcoords: ' + str(self.xcoords) + '\n ycoords: ' + str(self.ycoords) + '\n'
def __repr__(self):
return '* label: ' + self.label + '\n xcoords: ' + str(self.xcoords) + '\n ycoords: ' + str(self.ycoords) + '\n'
In [7]:
class img_meta:
# img_name: image file name
# annotations: the annotation list
def __str__(self):
return 'img_name: ' + self.img_name + ', annotations: \n' + str(self.annotations)
def __repr__(self):
return 'img_name: ' + self.img_name + ', annotations: \n' + str(self.annotations)
def parse(self, anno_file_name):
anno_file_path = os.path.join(anno_path, anno_file_name)
with open(anno_file_path, 'r') as file:
csvReader = csv.DictReader(file)
self.annotations = []
for idx, rows in enumerate(csvReader):
anno_obj = annotation()
if idx == 0: self.img_name = rows['filename'] # get image file name from the first row
region_attributes = rows['region_attributes']
region_attributes = json.loads(region_attributes) # convert to dict
anno_obj.label = region_attributes['class'] # get annotation class
region_shape_attributes = json.loads(rows['region_shape_attributes'])
anno_obj.xcoords = region_shape_attributes['all_points_x']
anno_obj.ycoords = region_shape_attributes['all_points_y']
self.annotations.append(anno_obj)
#This function uses opencv rather than PIL to load image.
#PIL has issues with the image channel
def load_image(self):
img_file_path = os.path.join(img_path, self.img_name)
"""Load the specified image and return a [H,W,3] Numpy array.
"""
# Load image
image = cv2.imread(img_file_path)
# If grayscale. Convert to RGB for consistency.
if image.ndim != 3:
image = skimage.color.gray2rgb(image)
# If has an alpha channel, remove it for consistency
if image.shape[-1] == 4:
image = image[..., :3]
return image
#horizontal image augmentation
def horizontal_image_augmentation(self, anno_file_name,image_width_size):
anno_file_path = os.path.join(anno_path, anno_file_name)
with open(anno_file_path, 'r') as file:
csvReader = csv.DictReader(file)
self.annotations = []
for idx, rows in enumerate(csvReader):
anno_obj = annotation()
if idx == 0: self.img_name = rows['filename'] # get image file name from the first row
region_attributes = rows['region_attributes']
region_attributes = json.loads(region_attributes) # convert to dict
anno_obj.label = region_attributes['class'] # get annotation class
region_shape_attributes = json.loads(rows['region_shape_attributes'])
anno_obj.xcoords = region_shape_attributes['all_points_x']
anno_obj.ycoords = region_shape_attributes['all_points_y']
#print(type(anno_obj.xcoords))
anno_obj.xcoords = [image_width_size-x for x in anno_obj.xcoords]
self.annotations.append(anno_obj)
#vertical image augmentation
def vertical_image_augmentation(self, anno_file_name,image_height_size):
anno_file_path = os.path.join(anno_path, anno_file_name)
with open(anno_file_path, 'r') as file:
csvReader = csv.DictReader(file)
self.annotations = []
for idx, rows in enumerate(csvReader):
anno_obj = annotation()
if idx == 0: self.img_name = rows['filename'] # get image file name from the first row
region_attributes = rows['region_attributes']
region_attributes = json.loads(region_attributes) # convert to dict
anno_obj.label = region_attributes['class'] # get annotation class
region_shape_attributes = json.loads(rows['region_shape_attributes'])
anno_obj.xcoords = region_shape_attributes['all_points_x']
anno_obj.ycoords = region_shape_attributes['all_points_y']
#print(type(anno_obj.xcoords))
anno_obj.ycoords = [image_height_size-x for x in anno_obj.ycoords]
self.annotations.append(anno_obj)
Parse an annotation file¶
In [8]:
# test the parsing of one annotation file
test_anno_file = 'Adityap_via_project_42.csv'
img_meta_obj = img_meta()
img_meta_obj.parse(test_anno_file)
#print(type(img_meta_obj))
pprint.pprint(img_meta_obj)
img_obj = img_meta_obj.load_image()
image_shape=img_obj.shape
print(image_shape[0],image_shape[1])
#print(img_obj.shape)
print("###########")
img_meta_obj.horizontal_image_augmentation(test_anno_file,image_shape[0])
pprint.pprint(img_meta_obj)
print("###########")
img_meta_obj.vertical_image_augmentation(test_anno_file,image_shape[1])
pprint.pprint(img_meta_obj)
In [9]:
#pprint.pprint(img_meta_obj)
In [9]:
In [10]:
img_obj = img_meta_obj.load_image()
image_shape=img_obj.shape
print(image_shape[0],image_shape[1])
print(img_obj.shape)
visualize.display_images([img_obj])
In [11]:
#img_obj_vertical_flip = cv2.flip(img_obj, 0)
#visualize.display_images([img_obj_vertical_flip]) #show the vertically flipped image
#img_obj_horizontal_flip = cv2.flip(img_obj, 1)
#visualize.display_images([img_obj_horizontal_flip]) #show the vertically flipped image
Parse all annotation files¶
In [12]:
img_metas = []
file_name=[]
for file in os.listdir(anno_path):
if file.endswith('.csv'):
print('Parsing', file, '...')
img_meta_obj = img_meta()
file_name.append(file)
img_meta_obj.parse(file)
img_metas.append(img_meta_obj)
else:
print('[WARNING] Non-CSV file detected:', file)
In [13]:
print(len(img_metas))
In [14]:
print(file_name[0])
Visualization¶
In [15]:
def load_mask(img_file, img_meta_obj):
h = img_file.shape[0]
w = img_file.shape[1]
#print(w)
#print(h)
annotations = img_meta_obj.annotations
#print(annotations)
# create one array for all masks, each on a different channel
masks = np.zeros([h, w, len(annotations)], dtype='uint8')
#print(masks)
#Draw polygons in empty mask
for i, r in enumerate(annotations):
class_label = r.label
all_points_x = r.xcoords
all_points_y = r.ycoords
#assert (len(all_points_x) == len(all_points_y)), 'all_points_x != all_points_y'
rr, cc = skimage.draw.polygon(all_points_y, all_points_x)
masks[rr, cc, i] = 1
return masks
In [16]:
# Visualize a random file
#sample_idx = np.random.choice(len(img_metas))
sample_idx = 1
print("Sample Index: ", sample_idx)
#Image Meta Data
img_meta_obj = img_metas[sample_idx]
print("Number of annotations: ", len(img_meta_obj.annotations))
img_file = img_meta_obj.load_image()
print("Image shape: ", img_file.shape)
masks = load_mask(img_file, img_meta_obj)
print("Mask shape: ", masks.shape)
visualize.display_masked_instances(img_file, img_meta_obj.annotations, masks)
In [17]:
# Visualize a random file
#sample_idx = np.random.choice(len(img_metas))
for sample_idx in range(0,1):
#sample_idx = 1
print("Sample Index: ", sample_idx)
img_meta_obj = img_meta()
img_meta_obj.parse(file_name[sample_idx])
#Image Meta Data
#img_meta_obj = img_metas[sample_idx]
print("Number of annotations: ", len(img_meta_obj.annotations))
img_file = img_meta_obj.load_image()
print("Image shape: ", img_file.shape)
masks = load_mask(img_file, img_meta_obj)
print("Mask shape: ", masks.shape)
visualize.display_masked_instances(img_file, img_meta_obj.annotations, masks)
# test the parsing of one annotation file
#test_anno_file = 'Adityap_via_project_42.csv'
image_shape=img_file.shape
img_obj_vertical_flip = cv2.flip(img_file, 0)
#visualize.display_images([img_obj_vertical_flip]) #show the vertically flipped image
img_obj_horizontal_flip = cv2.flip(img_file, 1)
#visualize.display_images([img_obj_horizontal_flip]) #show the horizotal flipped image
print(image_shape[0],image_shape[1])
#print(img_obj.shape)
print("###########")
img_meta_obj_horizontal = img_meta()
img_meta_obj_horizontal.horizontal_image_augmentation(file_name[sample_idx],image_shape[1])
#pprint.pprint(img_meta_obj)
#sample_idx = 2
#print("Sample Index: ", sample_idx)
#Image Meta Data
#img_meta_obj = img_metas[sample_idx]
print("Number of annotations: ", len(img_meta_obj_horizontal.annotations))
img_file = img_meta_obj_horizontal.load_image()
print("Image shape: ", img_file.shape)
masks_hori = load_mask(img_obj_horizontal_flip, img_meta_obj_horizontal)
print("Mask shape: ", masks_hori.shape)
print("sample index=",sample_idx," after horizontal flipping")
visualize.display_masked_instances(img_obj_horizontal_flip, img_meta_obj_horizontal.annotations, masks_hori)
print("###########")
img_meta_obj_vertical = img_meta()
img_meta_obj_vertical.vertical_image_augmentation(file_name[sample_idx],image_shape[0])
#pprint.pprint(img_meta_obj)
masks_verti = load_mask(img_obj_vertical_flip, img_meta_obj_vertical)
print("Mask shape: ", masks_verti.shape)
print("sample index=",sample_idx,"after vertical flipping")
visualize.display_masked_instances(img_obj_vertical_flip, img_meta_obj_vertical.annotations, masks_verti)
FCN Demo¶
Data Processing¶
In [18]:
# Image size that we are going to use
IMG_SIZE = 256
# Our images are RGB (3 channels)
N_CHANNELS = 3
# Foreground and backgroung
N_CLASSES = 2
In [19]:
#Loads the data and creates a tuple of images
#masks to be later made into Tensorflow data object
def dataLoader():
img_list = []
mask_list = []
for i in range(len(img_metas)):
img_meta_obj = img_metas[i]
#print(file_name[i])
img_file = img_meta_obj.load_image()
#print("Image shape: ", img_file.shape)
#Convert mask to the shape of an image (3D) with channel=1
masks = load_mask(img_file, img_meta_obj)
#print("Masks shape: ", masks.shape)
#Merge all separate masks to one mask
mask = np.sum(masks, axis = -1)
#print("Mask shape: ", mask.shape)
mask = np.expand_dims(mask, axis = -1)
#print("Mask shape: ", mask.shape)
#Rezize mask and image to common size
# Resize Image to 256x256
img_file, _, scale, padding,_ = my_utils.resize_image(img_file, max_dim = IMG_SIZE, mode="square")
#print("Image shape: ", img_file.shape)
# Resize Mask to 256x256
mask = my_utils.resize_mask(mask, scale, padding)
#Fix Overlap bug
mask = np.where(mask > 1, 1, mask)
mask = mask.astype(np.float32)
#print(np.amax(mask))
#print("Mask shape: ", mask.shape)
#Normalize Image
img_file = img_file.astype(np.float32)
img_file = img_file/255.0
#print("Image shape: ", img_file.shape)
img_list.append(img_file)
mask_list.append(mask)
# for horizontal flip
img_meta_obj = img_metas[i]
img_file = img_meta_obj.load_image()
image_shape=img_file.shape
#print("Image shape: ", img_file.shape)
#horizontal flip image file
img_file = cv2.flip(img_file, 1)
img_meta_obj_horizontal = img_meta()
img_meta_obj_horizontal.horizontal_image_augmentation(file_name[i],image_shape[1])
#Convert mask to the shape of an image (3D) with channel=1
masks = load_mask(img_file, img_meta_obj_horizontal)
#print("Masks shape: ", masks.shape)
#Merge all separate masks to one mask
mask = np.sum(masks, axis = -1)
#print("Mask shape: ", mask.shape)
mask = np.expand_dims(mask, axis = -1)
#print("Mask shape: ", mask.shape)
#Rezize mask and image to common size
# Resize Image to 256x256
img_file, _, scale, padding,_ = my_utils.resize_image(img_file, max_dim = IMG_SIZE, mode="square")
#print("Image shape: ", img_file.shape)
# Resize Mask to 256x256
mask = my_utils.resize_mask(mask, scale, padding)
#Fix Overlap bug
mask = np.where(mask > 1, 1, mask)
mask = mask.astype(np.float32)
#print(np.amax(mask))
#print("Mask shape: ", mask.shape)
#Normalize Image
img_file = img_file.astype(np.float32)
img_file = img_file/255.0
#print("Image shape: ", img_file.shape)
img_list.append(img_file)
mask_list.append(mask)
# for vertical flip
img_meta_obj = img_metas[i]
img_file = img_meta_obj.load_image()
image_shape=img_file.shape
#print("Image shape: ", img_file.shape)
#vertical flip image file
img_file = cv2.flip(img_file, 0)
img_meta_obj_vertical = img_meta()
img_meta_obj_vertical.vertical_image_augmentation(file_name[i],image_shape[0])
#Convert mask to the shape of an image (3D) with channel=1
masks = load_mask(img_file, img_meta_obj_vertical)
#print("Masks shape: ", masks.shape)
#Merge all separate masks to one mask
mask = np.sum(masks, axis = -1)
#print("Mask shape: ", mask.shape)
mask = np.expand_dims(mask, axis = -1)
#print("Mask shape: ", mask.shape)
#Rezize mask and image to common size
# Resize Image to 256x256
img_file, _, scale, padding,_ = my_utils.resize_image(img_file, max_dim = IMG_SIZE, mode="square")
#print("Image shape: ", img_file.shape)
# Resize Mask to 256x256
mask = my_utils.resize_mask(mask, scale, padding)
#Fix Overlap bug
mask = np.where(mask > 1, 1, mask)
mask = mask.astype(np.float32)
#print(np.amax(mask))
#print("Mask shape: ", mask.shape)
#Normalize Image
img_file = img_file.astype(np.float32)
img_file = img_file/255.0
#print("Image shape: ", img_file.shape)
img_list.append(img_file)
mask_list.append(mask)
return (img_list, mask_list)
Create Tensorflow Data Loader¶
In [20]:
dataset = tf.data.Dataset.from_tensor_slices(dataLoader())
Train/Validation Split¶
In [21]:
train_size = int(0.9 * len(img_metas))
val_size = int(0.1 * len(img_metas))
train_dataset = dataset.take(train_size)
val_dataset = dataset.skip(train_size)
In [21]:
Training¶
The following training code and model code was adapted from¶
https://yann-leguilly.gitlab.io/post/2019-12-14-tensorflow-tfdata-segmentation/¶
Data Tuning Parameters¶
In [22]:
BATCH_SIZE = 5
BUFFER_SIZE = 1000
# important for reproducibility
# this allows to generate the same random numbers
SEED = 42
AUTOTUNE = tf.data.experimental.AUTOTUNE
In [23]:
dataset = {"train": train_dataset, "val": val_dataset}
# -- Train Dataset --#
#dataset['train'] = dataset['train'].shuffle(buffer_size=BUFFER_SIZE, seed=SEED)
dataset['train'] = dataset['train'].repeat()
dataset['train'] = dataset['train'].batch(BATCH_SIZE)
dataset['train'] = dataset['train'].prefetch(buffer_size=AUTOTUNE)
#-- Validation Dataset --#
dataset['val'] = dataset['val'].repeat()
dataset['val'] = dataset['val'].batch(BATCH_SIZE)
dataset['val'] = dataset['val'].prefetch(buffer_size=AUTOTUNE)
print(dataset['train'])
print(dataset['val'])
# how shuffle works: https://stackoverflow.com/a/53517848
In [24]:
def display_sample(display_list):
"""Show side-by-side an input image,
the ground truth and the prediction.
"""
plt.figure(figsize=(18, 18))
title = ['Input Image', 'True Mask', 'Predicted Mask']
for i in range(len(display_list)):
plt.subplot(1, len(display_list), i+1)
plt.title(title[i])
plt.imshow(tf.keras.preprocessing.image.array_to_img(display_list[i]))
plt.axis('off')
plt.show()
In [25]:
for image, mask in dataset['train'].take(1):
sample_image, sample_mask = image, mask
display_sample([sample_image[0], sample_mask[0]])
In [26]:
import tensorflow as tf
#def FCN_model(len_classes=5, dropout_rate=0.2):
dropout_rate = 0.5
input_size = (IMG_SIZE, IMG_SIZE, N_CHANNELS)
inputs = Input(shape=input_size)
#input = tf.keras.layers.Input(shape=(None, None, 3))
len_classes=2
#dropout_rate=0.2
x = tf.keras.layers.Conv2D(filters=32, kernel_size=3, strides=1)(inputs)
x = tf.keras.layers.Dropout(dropout_rate)(x)
x = tf.keras.layers.BatchNormalization()(x)
x = tf.keras.layers.Activation('relu')(x)
# x = tf.keras.layers.MaxPooling2D()(x)
x = tf.keras.layers.Conv2D(filters=64, kernel_size=3, strides=1)(x)
x = tf.keras.layers.Dropout(dropout_rate)(x)
x = tf.keras.layers.BatchNormalization()(x)
x = tf.keras.layers.Activation('relu')(x)
# x = tf.keras.layers.MaxPooling2D()(x)
x = tf.keras.layers.Conv2D(filters=128, kernel_size=3, strides=2)(x)
x = tf.keras.layers.Dropout(dropout_rate)(x)
x = tf.keras.layers.BatchNormalization()(x)
x = tf.keras.layers.Activation('relu')(x)
# x = tf.keras.layers.MaxPooling2D()(x)
x = tf.keras.layers.Conv2D(filters=256, kernel_size=3, strides=2)(x)
x = tf.keras.layers.Dropout(dropout_rate)(x)
x = tf.keras.layers.BatchNormalization()(x)
x = tf.keras.layers.Activation('relu')(x)
# x = tf.keras.layers.MaxPooling2D()(x)
x = tf.keras.layers.Conv2D(filters=512, kernel_size=3, strides=2)(x)
x = tf.keras.layers.Dropout(dropout_rate)(x)
x = tf.keras.layers.BatchNormalization()(x)
x = tf.keras.layers.Activation('relu')(x)
# Uncomment the below line if you're using dense layers
# x = tf.keras.layers.GlobalMaxPooling2D()(x)
# Fully connected layer 1
# x = tf.keras.layers.Dropout(dropout_rate)(x)
# x = tf.keras.layers.BatchNormalization()(x)
# x = tf.keras.layers.Dense(units=64)(x)
# x = tf.keras.layers.Activation('relu')(x)
# Fully connected layer 1
x = tf.keras.layers.Conv2D(filters=64, kernel_size=1, strides=1)(x)
x = tf.keras.layers.Dropout(dropout_rate)(x)
x = tf.keras.layers.BatchNormalization()(x)
x = tf.keras.layers.Activation('relu')(x)
# Fully connected layer 2
# x = tf.keras.layers.Dropout(dropout_rate)(x)
# x = tf.keras.layers.BatchNormalization()(x)
# x = tf.keras.layers.Dense(units=len_classes)(x)
# predictions = tf.keras.layers.Activation('softmax')(x)
# Fully connected layer 2
x = tf.keras.layers.Conv2D(filters=len_classes, kernel_size=1, strides=1)(x)
x = tf.keras.layers.Dropout(dropout_rate)(x)
x = tf.keras.layers.BatchNormalization()(x)
x = tf.keras.layers.GlobalMaxPooling2D()(x)
predictions = tf.keras.layers.Activation('softmax')(x)
output=predictions
#model = tf.keras.Model(inputs=inputs, outputs=predictions)
#print(model.summary())
#print(f'Total number of layers: {len(model.layers)}')
# return model
#if __name__ == "__main__":
# FCN_model(len_classes=5, dropout_rate=0.2)
In [27]:
# -- Keras Functional API -- #
# -- FC densenet Implementation -- #
# Everything here is from tensorflow.keras.layers
# I imported tensorflow.keras.layers * to make it easier to read
dropout_rate = 0.2
input_size = (IMG_SIZE, IMG_SIZE, N_CHANNELS)
# If you want to know more about why we are using `he_normal`:
# https://stats.stackexchange.com/questions/319323/whats-the-difference-between-variance-scaling-initializer-and-xavier-initialize/319849#319849
# Or the excelent fastai course:
# https://github.com/fastai/course-v3/blob/master/nbs/dl2/02b_initializing.ipynb
initializer = 'he_normal'
# -- Top Down -- #
inputs = Input(shape=input_size)
conv_enc_1 = Conv2D(256, 3, padding='same', kernel_initializer=initializer)(inputs)
# layer 1
x1=BatchNormalization()(conv_enc_1)
x1 = Conv2D(256, 3, activation = 'relu', padding='same', kernel_initializer=initializer)(x1)
x1 = tf.keras.layers.Dropout(dropout_rate)(x1)
concatenate_1 = concatenate([x1, conv_enc_1], axis = 3)
# Transition Down 1
td_x1=BatchNormalization()(concatenate_1)
td_x1 = Conv2D(256, 1, activation = 'relu', padding='same', kernel_initializer=initializer)(td_x1)
td_x1 = tf.keras.layers.Dropout(dropout_rate)(td_x1)
max_pool_enc_1 = MaxPooling2D(pool_size=(2, 2))(td_x1)
# layer 2
x2=BatchNormalization()(max_pool_enc_1)
x2 = Conv2D(256, 3, activation = 'relu', padding='same', kernel_initializer=initializer)(x2)
x2 = tf.keras.layers.Dropout(dropout_rate)(x2)
concatenate_2 = concatenate([x2, max_pool_enc_1], axis = 3)
# Transition Down 2
td_x2=BatchNormalization()(concatenate_2)
td_x2 = Conv2D(256, 1, activation = 'relu', padding='same', kernel_initializer=initializer)(td_x2)
td_x2 = tf.keras.layers.Dropout(dropout_rate)(td_x2)
max_pool_enc_2 = MaxPooling2D(pool_size=(2, 2))(td_x2)
# layer 3
x3=BatchNormalization()(max_pool_enc_2)
x3 = Conv2D(256, 3, activation = 'relu', padding='same', kernel_initializer=initializer)(x3)
x3 = tf.keras.layers.Dropout(dropout_rate)(x3)
#Transition UP 1
tu_x1 = Conv2DTranspose(256, 3, strides=(2,2), padding='same', kernel_initializer=initializer)(x3)
# layer 4
x4=BatchNormalization()(tu_x1)
x4 = Conv2D(256, 3, activation = 'relu', padding='same', kernel_initializer=initializer)(x4)
x4 = tf.keras.layers.Dropout(dropout_rate)(x4)
#Transition UP 2
tu_x2 = Conv2DTranspose(256, 3, strides=(2,2), padding='same', kernel_initializer=initializer)(x4)
# layer 5
x5=BatchNormalization()(tu_x2)
x5 = Conv2D(256, 3, activation = 'relu', padding='same', kernel_initializer=initializer)(x5)
x5 = tf.keras.layers.Dropout(dropout_rate)(x5)
output = Conv2D(256, 3, padding='same', kernel_initializer=initializer)(x5)
#output = Conv2D(N_CLASSES, 1, activation = 'softmax')(conv_dec_4)
Model Saver Class¶
In [28]:
#This class will automatically save TF models
#at Epoch which are multiples of the SAVE_MULTIPLE parameter.
SAVE_MULTIPLE = 5
class ModelSaver(tf.keras.callbacks.Callback):
def on_epoch_end(self, epoch, logs={}):
if (epoch)%SAVE_MULTIPLE == 0: # Save when epochs are multiples of SAVE_MULTIPLE.
self.model.save(f"./saved_models/model_{epoch}.h5")
Create and Compile Model¶
In [29]:
model = tf.keras.Model(inputs = inputs, outputs = output)
In [31]:
model.compile(optimizer=Adam(learning_rate=0.0001), loss = tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=['accuracy'])
Model Summary¶
In [32]:
model.summary()
Create moodel saver instance¶
In [31]:
# create and use callback:
saver = ModelSaver()
Training Hyperparameters¶
In [32]:
EPOCHS = 250
STEPS_PER_EPOCH = train_size // BATCH_SIZE
VALIDATION_STEPS = val_size // BATCH_SIZE
Start Training¶
In [33]:
# sometimes it can be very interesting to run some batches on cpu
# because the tracing is way better than on GPU
# you will have more obvious error message
# but in our case, it takes A LOT of time
# #On CPU
# with tf.device("/cpu:0"):
# model_history = model.fit(dataset['train'], epochs=EPOCHS,
# callbacks=[saver],
# steps_per_epoch=STEPS_PER_EPOCH,
# validation_steps=VALIDATION_STEPS,
# validation_data=dataset['val'])
#On GPU
model_history = model.fit(dataset['train'], epochs=EPOCHS,
callbacks=[saver],
steps_per_epoch=STEPS_PER_EPOCH,
validation_steps=VALIDATION_STEPS,
validation_data=dataset['val'])
Manually Save Model¶
In [34]:
# ## Save the model at the latest EPOCH or as desired
# model.save(f"./saved_models/model_{EPOCHS}.h5")
Load¶
In [35]:
MODEL_PATH = "./saved_models/model_20.h5" #Change this to the model path you want to load
model.load_weights(MODEL_PATH, by_name=True)
Process Prediction¶
In [36]:
import sys
np.set_printoptions(threshold=sys.maxsize)
In [37]:
#Pick first batch of Image from Validation set
for image, mask in dataset['val'].take(1):
sample_image, sample_mask = image, mask
In [38]:
#Pick first Prediction Validation set
sample_idx = 3
pred_mask = model.predict(sample_image)
sample_image = sample_image.numpy()[sample_idx] #Pick first image form a batch of 5
sample_image = (sample_image*255.0).astype(np.uint32)
#Ground Truth Mask
sample_mask = sample_mask.numpy()[sample_idx]
sample_mask = np.squeeze(sample_mask, axis =-1)
#Predicted Mask
pred_mask = pred_mask[sample_idx] #Pick first mask form a batch of 5
In [39]:
print(sample_image.shape)
print(pred_mask.shape)
In [40]:
pred_mask = np.argmax(pred_mask, axis =-1)
#pred_mask = np.expand_dims(pred_mask, axis =-1)
print(sample_image.shape)
print(pred_mask.shape)
In [41]:
#print(pred_mask)
Visualize Prediction¶
In [42]:
colors = visualize.random_colors(len(img_meta_obj.annotations))
color = colors[0]
print(color)
masked_image = sample_image.astype(np.uint32).copy()
masked_image = visualize.apply_mask(masked_image, pred_mask, color)
visualize.display_images([masked_image])
In [43]:
# Vizualize Ground Truth
In [44]:
#GT
colors = visualize.random_colors(len(img_meta_obj.annotations))
color = colors[0]
print(color)
masked_image = sample_image.astype(np.uint32).copy()
print(masked_image.shape)
print(sample_mask.shape)
masked_image = visualize.apply_mask(masked_image, sample_mask, color)
visualize.display_images([masked_image])
In [45]:
import sys
np.set_printoptions(threshold=sys.maxsize)
sample_idx=0
#Pick first batch of Image from Validation set
for image, mask in dataset['val'].take(5):
sample_image, sample_mask = image, mask
#Pick first Prediction Validation set
#for sample_idx in range(1):
pred_mask = model.predict(sample_image)
sample_image = sample_image.numpy()[sample_idx] #Pick first image form a batch of 5
sample_image = (sample_image*255.0).astype(np.uint32)
#Ground Truth Mask
sample_mask = sample_mask.numpy()[sample_idx]
sample_mask = np.squeeze(sample_mask, axis =-1)
#Predicted Mask
pred_mask = pred_mask[sample_idx] #Pick first mask form a batch of 5
pred_mask_IoU = np.argmax(pred_mask, axis =-1)
#Mean IoU
m = tf.keras.metrics.MeanIoU(num_classes=3)
m.update_state(sample_mask, pred_mask_IoU)
print("IoU =",m.result().numpy())
#prediction visualization
colors = visualize.random_colors(len(img_meta_obj.annotations))
color = colors[0]
print(color)
masked_image = sample_image.astype(np.uint32).copy()
pred_mask = np.argmax(pred_mask, axis =-1)
print(masked_image.shape)
print(pred_mask.shape)
masked_image = visualize.apply_mask(masked_image, pred_mask, color)
print("predict image")
visualize.display_images([masked_image])
#GT
colors = visualize.random_colors(len(img_meta_obj.annotations))
color = colors[0]
print(color)
masked_image = sample_image.astype(np.uint32).copy()
print(masked_image.shape)
print(sample_mask.shape)
masked_image = visualize.apply_mask(masked_image, sample_mask, color)
print("Ground Truth Image")
visualize.display_images([masked_image])
sample_idx=sample_idx+1
In [48]:
import sys
np.set_printoptions(threshold=sys.maxsize)
sample_idx=0
#Pick first batch of Image from Validation set
for image, mask in dataset['val'].take(5):
sample_image, sample_mask = image, mask
#Pick first Prediction Validation set
#for sample_idx in range(1):
pred_mask = model.predict(sample_image)
sample_image = sample_image.numpy()[sample_idx] #Pick first image form a batch of 5
sample_image = (sample_image*255.0).astype(np.uint32)
#Ground Truth Mask
sample_mask = sample_mask.numpy()[sample_idx]
sample_mask = np.squeeze(sample_mask, axis =-1)
#Predicted Mask
pred_mask = pred_mask[sample_idx] #Pick first mask form a batch of 5
pred_mask_IoU = np.argmax(pred_mask, axis =-1)
#Mean IoU
m = tf.keras.metrics.MeanIoU(num_classes=3)
m.update_state(sample_mask, pred_mask_IoU)
print("IoU =",m.result().numpy())
#prediction visualization
colors = visualize.random_colors(len(img_meta_obj.annotations))
color = colors[0]
print(color)
masked_image = sample_image.astype(np.uint32).copy()
pred_mask = np.argmax(pred_mask, axis =-1)
print(masked_image.shape)
print(pred_mask.shape)
masked_image = visualize.apply_mask(masked_image, pred_mask, color)
print("predict image")
visualize.display_images([masked_image])
#GT
colors = visualize.random_colors(len(img_meta_obj.annotations))
color = colors[0]
print(color)
masked_image = sample_image.astype(np.uint32).copy()
print(masked_image.shape)
print(sample_mask.shape)
masked_image = visualize.apply_mask(masked_image, sample_mask, color)
print("Ground Truth Image")
visualize.display_images([masked_image])
sample_idx=sample_idx+1
